ํ์ด์ฌ ๋ฐ์ฝ๋ ์ดํฐ ํจํด์ ํจ์ ๋ํ๊ณผ ๋ฉํ๋ฐ์ดํฐ ๋ณด์กด์ ๋น๊ตํ์ฌ ๊ฒฌ๊ณ ํ๊ณ ์ ์ง๋ณด์ ๊ฐ๋ฅํ ์ฝ๋๋ฅผ ์์ฑํ๋ ๋ฒ์ ์์๋ด ๋๋ค. ๋์์ธ ํจํด์ ๊น์ด ์ดํดํ๊ณ ์ ํ๋ ๊ธ๋ก๋ฒ ๊ฐ๋ฐ์์๊ฒ ์ ํฉํฉ๋๋ค.
๋ฐ์ฝ๋ ์ดํฐ ํจํด ๊ตฌํ: ํ์ด์ฌ์์์ ํจ์ ๋ํ๊ณผ ๋ฉํ๋ฐ์ดํฐ ๋ณด์กด ๋น๊ต
๋ฐ์ฝ๋ ์ดํฐ ํจํด์ ๊ธฐ์กด ๊ฐ์ฒด๋ ํจ์์ ๊ตฌ์กฐ๋ฅผ ๋ณ๊ฒฝํ์ง ์๊ณ ๋์ ์ผ๋ก ์๋ก์ด ๊ธฐ๋ฅ์ ์ถ๊ฐํ ์ ์๊ฒ ํด์ฃผ๋ ๊ฐ๋ ฅํ๊ณ ์ฐ์ํ ๋์์ธ ํจํด์ ๋๋ค. ํ์ด์ฌ์์ ๋ฐ์ฝ๋ ์ดํฐ๋ ์ด ํจํด์ ๋งค์ฐ ์ง๊ด์ ์ผ๋ก ๊ตฌํํ ์ ์๊ฒ ํด์ฃผ๋ ๋ฌธ๋ฒ์ ์คํ(syntactic sugar)์ ๋๋ค. ํ์ง๋ง ๊ฐ๋ฐ์๋ค, ํนํ ํ์ด์ฌ์ด๋ ๋์์ธ ํจํด์ ์ต์ํ์ง ์์ ๊ฐ๋ฐ์๋ค์ด ํํ ๊ฒช๋ ํจ์ ์ ๋จ์ํ ํจ์๋ฅผ ๊ฐ์ธ๋ ๊ฒ๊ณผ ์๋ณธ ํจ์์ ๋ฉํ๋ฐ์ดํฐ๋ฅผ ๋ณด์กดํ๋ ๊ฒ ์ฌ์ด์ ๋ฏธ๋ฌํ์ง๋ง ๊ฒฐ์ ์ ์ธ ์ฐจ์ด๋ฅผ ์ดํดํ๋ ๋ฐ ์์ต๋๋ค.
์ด ์ข ํฉ ๊ฐ์ด๋์์๋ ํ์ด์ฌ ๋ฐ์ฝ๋ ์ดํฐ์ ํต์ฌ ๊ฐ๋ ์ ๊น์ด ํ๊ณ ๋ค์ด, ๊ธฐ๋ณธ์ ์ธ ํจ์ ๋ํ ๋ฐฉ์๊ณผ ๋ ์ฐ์ํ ๋ฉํ๋ฐ์ดํฐ ๋ณด์กด ๋ฐฉ๋ฒ์ ๋๋ ทํ ์ฐจ์ด์ ์ ๊ฐ์กฐํ ๊ฒ์ ๋๋ค. ํนํ ํ์ ๋ฐ ๊ธ๋ก๋ฒ ๊ฐ๋ฐ ํ๊ฒฝ์์ ์ ๋ฉํ๋ฐ์ดํฐ ๋ณด์กด์ด ๊ฒฌ๊ณ ํ๊ณ , ํ ์คํธ ๊ฐ๋ฅํ๋ฉฐ, ์ ์ง๋ณด์ ๊ฐ๋ฅํ ์ฝ๋๋ฅผ ์ํด ํ์์ ์ธ์ง ํ๊ตฌํด ๋ณด๊ฒ ์ต๋๋ค.
ํ์ด์ฌ์ ๋ฐ์ฝ๋ ์ดํฐ ํจํด ์ดํดํ๊ธฐ
๋ณธ์ง์ ์ผ๋ก ํ์ด์ฌ์ ๋ฐ์ฝ๋ ์ดํฐ๋ ๋ค๋ฅธ ํจ์๋ฅผ ์ธ์๋ก ๋ฐ์, ์ด๋ค ๊ธฐ๋ฅ์ ์ถ๊ฐํ ๋ค์, ๋ ๋ค๋ฅธ ํจ์๋ฅผ ๋ฐํํ๋ ํจ์์ ๋๋ค. ์ด ๋ฐํ๋ ํจ์๋ ์ข ์ข ์์ ๋๊ฑฐ๋ ๊ธฐ๋ฅ์ด ์ถ๊ฐ๋ ์๋ณธ ํจ์์ด๊ฑฐ๋, ์๋ณธ ํจ์๋ฅผ ํธ์ถํ๋ ์์ ํ ์๋ก์ด ํจ์์ผ ์ ์์ต๋๋ค.
ํ์ด์ฌ ๋ฐ์ฝ๋ ์ดํฐ์ ๊ธฐ๋ณธ ๊ตฌ์กฐ
๊ธฐ๋ณธ์ ์ธ ์์๋ถํฐ ์์ํ๊ฒ ์ต๋๋ค. ํจ์๊ฐ ํธ์ถ๋ ๋ ๋ก๊ทธ๋ฅผ ๋จ๊ธฐ๊ณ ์ถ๋ค๊ณ ๊ฐ์ ํด ๋ด ์๋ค. ๊ฐ๋จํ ๋ฐ์ฝ๋ ์ดํฐ๋ก ์ด๋ฅผ ๋ฌ์ฑํ ์ ์์ต๋๋ค:
def simple_logger_decorator(func):
def wrapper(*args, **kwargs):
print(f"Calling function: {func.__name__}")
result = func(*args, **kwargs)
print(f"Finished calling function: {func.__name__}")
return result
return wrapper
@simple_logger_decorator
def greet(name):
return f"Hello, {name}!"
print(greet("Alice"))
์ด ์ฝ๋๋ฅผ ์คํํ๋ฉด ์ถ๋ ฅ์ ๋ค์๊ณผ ๊ฐ์ต๋๋ค:
Calling function: greet
Hello, Alice!
Finished calling function: greet
์ด๋ ๋ก๊น
์ ์ถ๊ฐํ๋ ๋ฐ ์๋ฒฝํ๊ฒ ์๋ํฉ๋๋ค. @simple_logger_decorator ๊ตฌ๋ฌธ์ greet = simple_logger_decorator(greet)์ ์ถ์ฝํ์
๋๋ค. wrapper ํจ์๋ ์๋ณธ greet ํจ์ ์คํ ์ ํ์ ์คํ๋์ด ์ํ๋ ๋ถ์ ํจ๊ณผ(side effect)๋ฅผ ๋ฌ์ฑํฉ๋๋ค.
๊ธฐ๋ณธ์ ์ธ ํจ์ ๋ํ์ ๋ฌธ์ ์
simple_logger_decorator๋ ํต์ฌ ๋ฉ์ปค๋์ฆ์ ๋ณด์ฌ์ฃผ์ง๋ง, ์ฌ๊ฐํ ๋จ์ ์ด ์์ต๋๋ค: ์๋ณธ ํจ์์ ๋ฉํ๋ฐ์ดํฐ๋ฅผ ์์ด๋ฒ๋ฆฐ๋ค๋ ์ ์
๋๋ค. ๋ฉํ๋ฐ์ดํฐ๋ ํจ์ ์ด๋ฆ, ๋
์คํธ๋ง(docstring), ์ด๋
ธํ
์ด์
(annotation)๊ณผ ๊ฐ์ด ํจ์ ์์ฒด์ ๋ํ ์ ๋ณด๋ฅผ ์๋ฏธํฉ๋๋ค.
๋ฐ์ฝ๋ ์ดํธ๋ greet ํจ์์ ๋ฉํ๋ฐ์ดํฐ๋ฅผ ๊ฒ์ฌํด ๋ด
์๋ค:
print(f"Function name: {greet.__name__}")
print(f"Docstring: {greet.__doc__}")
@simple_logger_decorator๋ฅผ ์ ์ฉํ ํ ์ด ์ฝ๋๋ฅผ ์คํํ๋ฉด ๋ค์๊ณผ ๊ฐ์ ๊ฒฐ๊ณผ๊ฐ ๋์ต๋๋ค:
Function name: wrapper
Docstring: None
๋ณด์๋ค์ํผ, ํจ์ ์ด๋ฆ์ ์ด์ 'wrapper'์ด๊ณ ๋
์คํธ๋ง์ None์
๋๋ค. ์ด๋ ๋ฐ์ฝ๋ ์ดํฐ๊ฐ wrapper ํจ์๋ฅผ ๋ฐํํ๊ณ , ํ์ด์ฌ์ ์ธํธ๋ก์คํ์
(introspection) ๋๊ตฌ๋ค์ด ์ด์ ์๋ณธ greet ํจ์๊ฐ ์๋ wrapper ํจ์๋ฅผ ์ค์ ๋ฐ์ฝ๋ ์ดํธ๋ ํจ์๋ก ๋ณด๊ธฐ ๋๋ฌธ์
๋๋ค.
๋ฉํ๋ฐ์ดํฐ ๋ณด์กด์ด ์ค์ํ ์ด์
ํจ์ ๋ฉํ๋ฐ์ดํฐ๋ฅผ ์์ด๋ฒ๋ฆฌ๋ฉด, ํนํ ๋๊ท๋ชจ ํ๋ก์ ํธ์ ๋ค์ํ ํ์์ ์ฌ๋ฌ ๋ฌธ์ ๊ฐ ๋ฐ์ํ ์ ์์ต๋๋ค:
- ๋๋ฒ๊น ์ ์ด๋ ค์: ๋๋ฒ๊น ์ ์คํ ํธ๋ ์ด์ค์์ ์๋ชป๋ ํจ์ ์ด๋ฆ์ ๋ณด๋ฉด ๋งค์ฐ ํผ๋์ค๋ฌ์ธ ์ ์์ต๋๋ค. ์ค๋ฅ์ ์ ํํ ์์น๋ฅผ ์ฐพ์๋ด๊ธฐ๊ฐ ๋ ์ด๋ ค์์ง๋๋ค.
- ์ธํธ๋ก์คํ์ ๊ฐ์: ๋ฌธ์ ์์ฑ๊ธฐ(์: Sphinx), ๋ฆฐํฐ, IDE์ ๊ฐ์ด ํจ์ ๋ฉํ๋ฐ์ดํฐ์ ์์กดํ๋ ๋๊ตฌ๋ค์ด ๋ฐ์ฝ๋ ์ดํธ๋ ํจ์์ ๋ํ ์ ํํ ์ ๋ณด๋ฅผ ์ ๊ณตํ ์ ์๊ฒ ๋ฉ๋๋ค.
- ํ ์คํธ ๋ฐฉํด: ๋จ์ ํ ์คํธ๊ฐ ํจ์ ์ด๋ฆ์ด๋ ๋ ์คํธ๋ง์ ๋ํ ๊ฐ์ ์ ํ๋ค๋ฉด ์คํจํ ์ ์์ต๋๋ค.
- ์ฝ๋ ๊ฐ๋ ์ฑ ๋ฐ ์ ์ง๋ณด์์ฑ ์ ํ: ๋ช ํํ๊ณ ์ค๋ช ์ ์ธ ํจ์ ์ด๋ฆ๊ณผ ๋ ์คํธ๋ง์ ์ฝ๋๋ฅผ ์ดํดํ๋ ๋ฐ ํ์์ ์ ๋๋ค. ์ด๋ฅผ ์์ด๋ฒ๋ฆฌ๋ฉด ํ์ ๊ณผ ์ฅ๊ธฐ์ ์ธ ์ ์ง๋ณด์๋ฅผ ๋ฐฉํดํฉ๋๋ค.
- ํ๋ ์์ํฌ ํธํ์ฑ: ๋ง์ ํ์ด์ฌ ํ๋ ์์ํฌ์ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ ํน์ ๋ฉํ๋ฐ์ดํฐ๊ฐ ์กด์ฌํ ๊ฒ์ผ๋ก ์์ํฉ๋๋ค. ์ด ๋ฉํ๋ฐ์ดํฐ๊ฐ ์์ค๋๋ฉด ์๊ธฐ์น ์์ ๋์์ด๋ ์ฌ๊ฐํ ์ค๋ฅ๊ฐ ๋ฐ์ํ ์ ์์ต๋๋ค.
๋ณต์กํ ์ ํ๋ฆฌ์ผ์ด์ ์ ๊ฐ๋ฐํ๋ ๊ธ๋ก๋ฒ ์ํํธ์จ์ด ๊ฐ๋ฐํ์ ์๊ฐํด ๋ณด์ธ์. ๋ง์ฝ ๋ฐ์ฝ๋ ์ดํฐ๊ฐ ํ์์ ์ธ ํจ์ ์ด๋ฆ๊ณผ ์ค๋ช ์ ์ ๊ฑฐํด ๋ฒ๋ฆฐ๋ค๋ฉด, ์๋ก ๋ค๋ฅธ ๋ฌธํ์ , ์ธ์ด์ ๋ฐฐ๊ฒฝ์ ๊ฐ์ง ๊ฐ๋ฐ์๋ค์ด ์ฝ๋๋ฒ ์ด์ค๋ฅผ ํด์ํ๋ ๋ฐ ์ด๋ ค์์ ๊ฒช์ด ์คํด์ ์ค๋ฅ๋ก ์ด์ด์ง ์ ์์ต๋๋ค. ๋ช ํํ๊ฒ ๋ณด์กด๋ ๋ฉํ๋ฐ์ดํฐ๋ ์์น๋ ํน์ ๋ชจ๋์ ๋ํ ์ฌ์ ๊ฒฝํ์ ๊ด๊ณ์์ด ๋ชจ๋ ์ฌ๋์๊ฒ ์ฝ๋์ ์๋๊ฐ ๋ช ํํ๊ฒ ์ ๋ฌ๋๋๋ก ๋ณด์ฅํฉ๋๋ค.
functools.wraps๋ฅผ ์ด์ฉํ ๋ฉํ๋ฐ์ดํฐ ๋ณด์กด
๋คํํ๋, ํ์ด์ฌ ํ์ค ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ ์ด ๋ฌธ์ ์ ๋ํ ๋ด์ฅ ํด๊ฒฐ์ฑ
์ ์ ๊ณตํฉ๋๋ค: ๋ฐ๋ก functools.wraps ๋ฐ์ฝ๋ ์ดํฐ์
๋๋ค. ์ด ๋ฐ์ฝ๋ ์ดํฐ๋ ๋ฐ์ฝ๋ ์ดํธ๋ ํจ์์ ๋ฉํ๋ฐ์ดํฐ๋ฅผ ๋ณด์กดํ๊ธฐ ์ํด ๋ค๋ฅธ ๋ฐ์ฝ๋ ์ดํฐ ๋ด์์ ์ฌ์ฉ๋๋๋ก ํน๋ณํ ์ค๊ณ๋์์ต๋๋ค.
functools.wraps์ ์๋ ๋ฐฉ์
wrapper ํจ์์ @functools.wraps(func)๋ฅผ ์ ์ฉํ๋ฉด, ์๋ณธ ํจ์(func)์ ์ด๋ฆ, ๋
์คํธ๋ง, ์ด๋
ธํ
์ด์
๋ฐ ๊ธฐํ ์ค์ํ ์์ฑ๋ค์ ๋ํผ ํจ์๋ก ๋ณต์ฌํฉ๋๋ค. ์ด๋ก ์ธํด ๋ํผ ํจ์๋ ์ธ๋ถ ์ธ๊ณ์ ๋ง์น ์๋ณธ ํจ์์ธ ๊ฒ์ฒ๋ผ ๋ณด์ด๊ฒ ๋ฉ๋๋ค.
์ฐ๋ฆฌ์ simple_logger_decorator๋ฅผ functools.wraps๋ฅผ ์ฌ์ฉํ๋๋ก ๋ฆฌํฉํ ๋งํด ๋ณด๊ฒ ์ต๋๋ค:
import functools
def preserved_logger_decorator(func):
@functools.wraps(func)
def wrapper(*args, **kwargs):
print(f"Calling function: {func.__name__}")
result = func(*args, **kwargs)
print(f"Finished calling function: {func.__name__}")
return result
return wrapper
@preserved_logger_decorator
def greet_with_preservation(name):
"""Greets a person by name."""
return f"Hello, {name}!"
print(greet_with_preservation("Bob"))
print(f"Function name: {greet_with_preservation.__name__}")
print(f"Docstring: {greet_with_preservation.__doc__}")
์ด์ ์ด ๊ฐ์ ๋ ๋ฐ์ฝ๋ ์ดํฐ๋ฅผ ์ ์ฉํ ํ์ ์ถ๋ ฅ์ ์ดํด๋ณด๊ฒ ์ต๋๋ค:
Calling function: greet_with_preservation
Hello, Bob!
Finished calling function: greet_with_preservation
Function name: greet_with_preservation
Docstring: Greets a person by name.
๋ณด์๋ค์ํผ, ํจ์ ์ด๋ฆ๊ณผ ๋ ์คํธ๋ง์ด ์ ํํ๊ฒ ๋ณด์กด๋์์ต๋๋ค! ์ด๊ฒ์ ์ฐ๋ฆฌ ๋ฐ์ฝ๋ ์ดํฐ๋ฅผ ํจ์ฌ ๋ ์ ๋ฌธ์ ์ด๊ณ ์ฌ์ฉํ๊ธฐ ์ฝ๊ฒ ๋ง๋๋ ์ค์ํ ๊ฐ์ ์ ๋๋ค.
์ค์ฉ์ ์ธ ์ ์ฉ ์ฌ๋ก ๋ฐ ๊ณ ๊ธ ์๋๋ฆฌ์ค
๋ฐ์ฝ๋ ์ดํฐ ํจํด, ํนํ ๋ฉํ๋ฐ์ดํฐ ๋ณด์กด ๊ธฐ๋ฅ์ ๊ฐ์ถ ๋ฐ์ฝ๋ ์ดํฐ ํจํด์ ํ์ด์ฌ ๊ฐ๋ฐ์์ ๊ด๋ฒ์ํ ์์ฉ ๋ถ์ผ๋ฅผ ๊ฐ์ง๋๋ค. ๊ธ๋ก๋ฒ ๊ฐ๋ฐ์ ์ปค๋ฎค๋ํฐ์ ๊ด๋ จ๋ ๋ค์ํ ๋งฅ๋ฝ์์ ๊ทธ ์ ์ฉ์ฑ์ ๊ฐ์กฐํ๋ ๋ช ๊ฐ์ง ์ค์ ์ฌ๋ก๋ฅผ ์ดํด๋ณด๊ฒ ์ต๋๋ค.
1. ์ ๊ทผ ์ ์ด ๋ฐ ๊ถํ
์น ํ๋ ์์ํฌ๋ API ๊ฐ๋ฐ์์ ์ฌ์ฉ์ ์ญํ ์ด๋ ๊ถํ์ ๋ฐ๋ผ ํน์ ํจ์์ ๋ํ ์ ๊ทผ์ ์ ํํด์ผ ํ๋ ๊ฒฝ์ฐ๊ฐ ๋ง์ต๋๋ค. ๋ฐ์ฝ๋ ์ดํฐ๋ ์ด ๋ก์ง์ ๊น๋ํ๊ฒ ์ฒ๋ฆฌํ ์ ์์ต๋๋ค.
import functools
def requires_admin_role(func):
@functools.wraps(func)
def wrapper(*args, **kwargs):
current_user = kwargs.get('user') # Assuming user info is passed as a keyword argument
if current_user and current_user.role == 'admin':
return func(*args, **kwargs)
else:
return "Access Denied: Administrator role required."
return wrapper
class User:
def __init__(self, name, role):
self.name = name
self.role = role
@requires_admin_role
def delete_user(user_id, user):
return f"User {user_id} deleted by {user.name}."
admin_user = User("GlobalAdmin", "admin")
regular_user = User("RegularUser", "user")
# Example calls with metadata preserved
print(delete_user(101, user=admin_user))
print(delete_user(102, user=regular_user))
# Introspection of the decorated function
print(f"Decorated function name: {delete_user.__name__}")
print(f"Decorated function docstring: {delete_user.__doc__}")
๊ธ๋ก๋ฒ ์ปจํ
์คํธ: ๋ถ์ฐ ์์คํ
์ด๋ ์ ์ธ๊ณ ์ฌ์ฉ์์๊ฒ ์๋น์ค๋ฅผ ์ ๊ณตํ๋ ํ๋ซํผ์์, ํ๊ฐ๋ ์ธ์๋ง์ด ๋ฏผ๊ฐํ ์์
(์: ์ฌ์ฉ์ ๊ณ์ ์ญ์ )์ ์ํํ ์ ์๋๋ก ๋ณด์ฅํ๋ ๊ฒ์ ๋งค์ฐ ์ค์ํฉ๋๋ค. @functools.wraps๋ฅผ ์ฌ์ฉํ๋ฉด, ๋ฌธ์ํ ๋๊ตฌ๋ฅผ ์ฌ์ฉํ์ฌ API ๋ฌธ์๋ฅผ ์์ฑํ ๊ฒฝ์ฐ ํจ์ ์ด๋ฆ๊ณผ ์ค๋ช
์ด ์ ํํ๊ฒ ์ ์ง๋๋ฏ๋ก, ๋ค๋ฅธ ์๊ฐ๋์ ์๊ฑฐ๋ ์ ๊ทผ ์์ค์ด ๋ค๋ฅธ ๊ฐ๋ฐ์๋ค์ด ์์คํ
์ ๋ ์ฝ๊ฒ ์ดํดํ๊ณ ํตํฉํ ์ ์์ต๋๋ค.
2. ์ฑ๋ฅ ๋ชจ๋ํฐ๋ง ๋ฐ ์๊ฐ ์ธก์
ํจ์์ ์คํ ์๊ฐ์ ์ธก์ ํ๋ ๊ฒ์ ์ฑ๋ฅ ์ต์ ํ์ ๋งค์ฐ ์ค์ํฉ๋๋ค. ๋ฐ์ฝ๋ ์ดํฐ๋ ์ด ๊ณผ์ ์ ์๋ํํ ์ ์์ต๋๋ค.
import functools
import time
def timing_decorator(func):
@functools.wraps(func)
def wrapper(*args, **kwargs):
start_time = time.time()
result = func(*args, **kwargs)
end_time = time.time()
print(f"Function '{func.__name__}' took {end_time - start_time:.4f} seconds to execute.")
return result
return wrapper
@timing_decorator
def complex_calculation(n):
"""Performs a computationally intensive task."""
time.sleep(1) # Simulate work
return sum(i*i for i in range(n))
result = complex_calculation(100000)
print(f"Calculation result: {result}")
print(f"Timing function name: {complex_calculation.__name__}")
print(f"Timing function docstring: {complex_calculation.__doc__}")
๊ธ๋ก๋ฒ ์ปจํ ์คํธ: ๋คํธ์ํฌ ์ง์ฐ ์๊ฐ์ด๋ ์๋ฒ ๋ถํ๊ฐ ๋ค๋ฅธ ์ฌ๋ฌ ์ง์ญ์ ์ฌ์ฉ์๋ฅผ ์ํด ์ฝ๋๋ฅผ ์ต์ ํํ ๋, ์ ํํ ์๊ฐ ์ธก์ ์ ๋งค์ฐ ์ค์ํฉ๋๋ค. ์ด์ ๊ฐ์ ๋ฐ์ฝ๋ ์ดํฐ๋ฅผ ์ฌ์ฉํ๋ฉด ๊ฐ๋ฐ์๋ค์ด ํต์ฌ ๋ก์ง์ ๋ณต์กํ๊ฒ ๋ง๋ค์ง ์๊ณ ๋ ์ฑ๋ฅ ๋ณ๋ชฉ ํ์์ ์ฝ๊ฒ ์๋ณํ ์ ์์ต๋๋ค. ๋ณด์กด๋ ๋ฉํ๋ฐ์ดํฐ๋ ์ฑ๋ฅ ๋ณด๊ณ ์๊ฐ ์ฌ๋ฐ๋ฅธ ํจ์์ ๋ช ํํ๊ฒ ๊ท์๋๋๋ก ๋ณด์ฅํ์ฌ, ๋ถ์ฐ๋ ํ์ ์์ง๋์ด๋ค์ด ๋ฌธ์ ๋ฅผ ํจ์จ์ ์ผ๋ก ์ง๋จํ๊ณ ํด๊ฒฐํ๋ ๋ฐ ๋์์ ์ค๋๋ค.
3. ๊ฒฐ๊ณผ ์บ์ฑ
๊ณ์ฐ ๋น์ฉ์ด ๋๊ณ ๋์ผํ ์ธ์๋ก ๋ฐ๋ณต์ ์ผ๋ก ํธ์ถ๋๋ ํจ์์ ๊ฒฝ์ฐ, ์บ์ฑ์ ์ฑ๋ฅ์ ํฌ๊ฒ ํฅ์์ํฌ ์ ์์ต๋๋ค. ํ์ด์ฌ์ functools.lru_cache๊ฐ ๋ํ์ ์ธ ์์์ด์ง๋ง, ํน์ ์๊ตฌ์ ๋ง๊ฒ ์ง์ ๋ง๋ค ์๋ ์์ต๋๋ค.
import functools
def simple_cache_decorator(func):
cache = {}
@functools.wraps(func)
def wrapper(*args, **kwargs):
# Create a cache key. For simplicity, only consider positional args.
# A real-world cache would need more sophisticated key generation,
# especially for kwargs and mutable types.
key = args
if key in cache:
print(f"Cache hit for '{func.__name__}' with args {args}")
return cache[key]
else:
print(f"Cache miss for '{func.__name__}' with args {args}")
result = func(*args, **kwargs)
cache[key] = result
return result
return wrapper
@simple_cache_decorator
def fibonacci(n):
"""Calculates the nth Fibonacci number recursively."""
if n < 2:
return n
return fibonacci(n - 1) + fibonacci(n - 2)
print(f"Fibonacci(10): {fibonacci(10)}")
print(f"Fibonacci(10) again: {fibonacci(10)}") # This should be a cache hit
print(f"Fibonacci function name: {fibonacci.__name__}")
print(f"Fibonacci function docstring: {fibonacci.__doc__}")
๊ธ๋ก๋ฒ ์ปจํ ์คํธ: ์ฌ๋ฌ ๋๋ฅ์ ์ฌ์ฉ์์๊ฒ ๋ฐ์ดํฐ๋ฅผ ์ ๊ณตํ ์ ์๋ ๊ธ๋ก๋ฒ ์ ํ๋ฆฌ์ผ์ด์ ์์, ์์ฃผ ์์ฒญ๋์ง๋ง ๊ณ์ฐ ๋น์ฉ์ด ๋ง์ด ๋๋ ๊ฒฐ๊ณผ๋ฅผ ์บ์ฑํ๋ฉด ์๋ฒ ๋ถํ์ ์๋ต ์๊ฐ์ ๋ํญ ์ค์ผ ์ ์์ต๋๋ค. ๋ฐ์ดํฐ ๋ถ์ ํ๋ซํผ์ ์์ํด ๋ณด์ธ์. ๋ณต์กํ ์ฟผ๋ฆฌ ๊ฒฐ๊ณผ๋ฅผ ์บ์ฑํ๋ฉด ์ ์ธ๊ณ ์ฌ์ฉ์์๊ฒ ๋ ๋น ๋ฅธ ์ธ์ฌ์ดํธ๋ฅผ ์ ๊ณตํ ์ ์์ต๋๋ค. ๋ฐ์ฝ๋ ์ดํธ๋ ์บ์ฑ ํจ์์ ๋ณด์กด๋ ๋ฉํ๋ฐ์ดํฐ๋ ์ด๋ค ๊ณ์ฐ์ด ์ ์บ์ฑ๋๊ณ ์๋์ง ์ดํดํ๋ ๋ฐ ๋์์ด ๋ฉ๋๋ค.
4. ์ ๋ ฅ๊ฐ ๊ฒ์ฆ
ํจ์ ์ ๋ ฅ๊ฐ์ด ํน์ ๊ธฐ์ค์ ์ถฉ์กฑํ๋์ง ํ์ธํ๋ ๊ฒ์ ํํ ์๊ตฌ์ฌํญ์ ๋๋ค. ๋ฐ์ฝ๋ ์ดํฐ๋ ์ด ๊ฒ์ฆ ๋ก์ง์ ์ค์์์ ๊ด๋ฆฌํ ์ ์์ต๋๋ค.
import functools
def validate_positive_integer(param_name):
def decorator(func):
@functools.wraps(func)
def wrapper(*args, **kwargs):
param_index = -1
try:
# Find the index of the parameter by name for positional arguments
param_index = func.__code__.co_varnames.index(param_name)
if param_index < len(args):
value = args[param_index]
if not isinstance(value, int) or value <= 0:
raise ValueError(f"'{param_name}' must be a positive integer.")
except ValueError:
# If not found as positional, check keyword arguments
if param_name in kwargs:
value = kwargs[param_name]
if not isinstance(value, int) or value <= 0:
raise ValueError(f"'{param_name}' must be a positive integer.")
else:
# Parameter not found, or it's optional and not provided
# Depending on requirements, you might want to raise an error here too
pass
return func(*args, **kwargs)
return wrapper
return decorator
@validate_positive_integer('count')
def process_items(items, count):
"""Processes a list of items a specified number of times."""
print(f"Processing {len(items)} items, {count} times.")
return len(items) * count
print(process_items(['a', 'b'], count=5))
try:
process_items(['c'], count=-2)
except ValueError as e:
print(e)
try:
process_items(['d'], count='three')
except ValueError as e:
print(e)
print(f"Validation function name: {process_items.__name__}")
print(f"Validation function docstring: {process_items.__doc__}")
๊ธ๋ก๋ฒ ์ปจํ ์คํธ: ๊ตญ์ ์ ์ธ ๋ฐ์ดํฐ์ ์ด๋ ์ฌ์ฉ์ ์ ๋ ฅ์ ๋ค๋ฃจ๋ ์ ํ๋ฆฌ์ผ์ด์ ์์๋ ๊ฐ๋ ฅํ ๊ฒ์ฆ์ด ์ค์ํฉ๋๋ค. ์๋ฅผ ๋ค์ด, ์๋, ๊ฐ๊ฒฉ ๋๋ ์ธก์ ๊ฐ์ ๋ํ ์ซ์ ์ ๋ ฅ์ ๊ฒ์ฆํ๋ฉด ๋ค๋ฅธ ์ง์ญํ ์ค์ ์ ๋ฐ์ ๊ฑธ์ณ ๋ฐ์ดํฐ ๋ฌด๊ฒฐ์ฑ์ ๋ณด์ฅํ ์ ์์ต๋๋ค. ๋ฉํ๋ฐ์ดํฐ๊ฐ ๋ณด์กด๋ ๋ฐ์ฝ๋ ์ดํฐ๋ฅผ ์ฌ์ฉํ๋ฉด ํจ์์ ๋ชฉ์ ๊ณผ ์์ ์ธ์๊ฐ ํญ์ ๋ช ํํด์ ธ, ์ ์ธ๊ณ ๊ฐ๋ฐ์๋ค์ด ๊ฒ์ฆ๋ ํจ์์ ๋ฐ์ดํฐ๋ฅผ ์ฌ๋ฐ๋ฅด๊ฒ ์ ๋ฌํ๊ธฐ๊ฐ ๋ ์ฌ์์ง๊ณ ๋ฐ์ดํฐ ํ์ ์ด๋ ๋ฒ์ ๋ถ์ผ์น์ ๊ด๋ จ๋ ์ผ๋ฐ์ ์ธ ์ค๋ฅ๋ฅผ ๋ฐฉ์งํ ์ ์์ต๋๋ค.
์ธ์๋ฅผ ๋ฐ๋ ๋ฐ์ฝ๋ ์ดํฐ ๋ง๋ค๊ธฐ
๋๋ก๋ ์์ฒด ์ธ์๋ก ๊ตฌ์ฑํ ์ ์๋ ๋ฐ์ฝ๋ ์ดํฐ๊ฐ ํ์ํฉ๋๋ค. ์ด๋ ํจ์ ์ค์ฒฉ์ ํ ๋จ๊ณ ๋ ์ถ๊ฐํ์ฌ ๊ตฌํํ ์ ์์ต๋๋ค.
import functools
def repeat(num_times):
def decorator_repeat(func):
@functools.wraps(func)
def wrapper(*args, **kwargs):
for _ in range(num_times):
result = func(*args, **kwargs)
return result
return wrapper
return decorator_repeat
@repeat(num_times=3)
def say_hello(name):
"""Prints a greeting."""
print(f"Hello, {name}!")
say_hello("World")
print(f"Repeat function name: {say_hello.__name__}")
print(f"Repeat function docstring: {say_hello.__doc__}")
์ด ํจํด์ ํน์ ์๊ตฌ์ ๋ง๊ฒ ์ฌ์ฉ์ ์ ์ํ ์ ์๋ ๋งค์ฐ ์ ์ฐํ ๋ฐ์ฝ๋ ์ดํฐ๋ฅผ ๊ฐ๋ฅํ๊ฒ ํฉ๋๋ค. @repeat(num_times=3) ๊ตฌ๋ฌธ์ say_hello = repeat(num_times=3)(say_hello)์ ์ถ์ฝํ์
๋๋ค. ์ธ๋ถ ํจ์ repeat๋ ๋ฐ์ฝ๋ ์ดํฐ์ ์ธ์๋ฅผ ๋ฐ๊ณ ์ค์ ๋ฐ์ฝ๋ ์ดํฐ(decorator_repeat)๋ฅผ ๋ฐํํ๋ฉฐ, ์ด ๋ฐ์ฝ๋ ์ดํฐ๊ฐ ๋ณด์กด๋ ๋ฉํ๋ฐ์ดํฐ์ ํจ๊ป ๋ก์ง์ ์ ์ฉํฉ๋๋ค.
๋ฐ์ฝ๋ ์ดํฐ ๊ตฌํ์ ์ํ ๋ชจ๋ฒ ์ฌ๋ก
์ฌ๋ฌ๋ถ์ ๋ฐ์ฝ๋ ์ดํฐ๊ฐ ์ ๋์ํ๊ณ , ์ ์ง๋ณด์ ๊ฐ๋ฅํ๋ฉฐ, ์ ์ธ๊ณ ์ฌ์ฉ์๋ค์ด ์ดํดํ ์ ์๋๋ก ํ๋ ค๋ฉด ๋ค์ ๋ชจ๋ฒ ์ฌ๋ก๋ฅผ ๋ฐ๋ฅด์ญ์์ค:
- ํญ์
@functools.wraps(func)์ฌ์ฉํ๊ธฐ: ์ด๊ฒ์ ๋ฉํ๋ฐ์ดํฐ ์์ค์ ํผํ๊ธฐ ์ํ ๊ฐ์ฅ ์ค์ํ ๋จ์ผ ์ค์ฒ ์ฌํญ์ ๋๋ค. ์ธํธ๋ก์คํ์ ๋๊ตฌ์ ๋ค๋ฅธ ๊ฐ๋ฐ์๋ค์ด ๋ฐ์ฝ๋ ์ดํธ๋ ํจ์๋ฅผ ์ ํํ๊ฒ ์ดํดํ ์ ์๋๋ก ๋ณด์ฅํฉ๋๋ค. - ์์น ์ธ์์ ํค์๋ ์ธ์๋ฅผ ์ฌ๋ฐ๋ฅด๊ฒ ์ฒ๋ฆฌํ๊ธฐ: ๋ํผ ํจ์์์
*args์**kwargs๋ฅผ ์ฌ์ฉํ์ฌ ๋ฐ์ฝ๋ ์ดํธ๋ ํจ์๊ฐ ๋ฐ์ ์ ์๋ ๋ชจ๋ ์ธ์๋ฅผ ์์ฉํ๋๋ก ํ์ญ์์ค. - ๋ฐ์ฝ๋ ์ดํธ๋ ํจ์์ ๊ฒฐ๊ณผ ๋ฐํํ๊ธฐ: ๋ํผ ํจ์๊ฐ ์๋ณธ ๋ฐ์ฝ๋ ์ดํธ๋ ํจ์๊ฐ ๋ฐํํ ๊ฐ์ ๋ฐํํ๋๋ก ํ์ญ์์ค.
- ๋ฐ์ฝ๋ ์ดํฐ๋ฅผ ์ง์ค๋ ๊ธฐ๋ฅ์ผ๋ก ์ ์งํ๊ธฐ: ๊ฐ ๋ฐ์ฝ๋ ์ดํฐ๋ ์ด์์ ์ผ๋ก ๋ก๊น , ์๊ฐ ์ธก์ , ์ธ์ฆ๊ณผ ๊ฐ์ ๋จ์ผํ๊ณ ์ ์ ์๋ ์์ ์ ์ํํด์ผ ํฉ๋๋ค. ์ฌ๋ฌ ๋ฐ์ฝ๋ ์ดํฐ๋ฅผ ๊ตฌ์ฑํ๋ ๊ฒ์ ๊ฐ๋ฅํ๋ฉฐ ์ข ์ข ๋ฐ๋์งํ์ง๋ง, ๊ฐ๋ณ ๋ฐ์ฝ๋ ์ดํฐ๋ ๋จ์ํด์ผ ํฉ๋๋ค.
- ๋ฐ์ฝ๋ ์ดํฐ ๋ฌธ์ํํ๊ธฐ: ๋ฐ์ฝ๋ ์ดํฐ๊ฐ ํ๋ ์ผ, ์ธ์(์๋ ๊ฒฝ์ฐ), ๊ทธ๋ฆฌ๊ณ ๋ถ์ ํจ๊ณผ๋ฅผ ์ค๋ช ํ๋ ๋ช ํํ ๋ ์คํธ๋ง์ ์์ฑํ์ญ์์ค. ์ด๊ฒ์ ์ ์ธ๊ณ ๊ฐ๋ฐ์๋ค์๊ฒ ๋งค์ฐ ์ค์ํฉ๋๋ค.
- ๋ฐ์ฝ๋ ์ดํฐ์ ์ธ์ ์ ๋ฌ ๊ณ ๋ คํ๊ธฐ: ๋ฐ์ฝ๋ ์ดํฐ์ ๊ตฌ์ฑ์ด ํ์ํ ๊ฒฝ์ฐ,
repeat์์์์ ๋ณด์ฌ์ค ๊ฒ์ฒ๋ผ ์ค์ฒฉ ๋ฐ์ฝ๋ ์ดํฐ ํจํด(๋ฐ์ฝ๋ ์ดํฐ ํฉํ ๋ฆฌ)์ ์ฌ์ฉํ์ญ์์ค. - ๋ฐ์ฝ๋ ์ดํฐ๋ฅผ ์ฒ ์ ํ ํ ์คํธํ๊ธฐ: ๋ฐ์ฝ๋ ์ดํฐ์ ๋ํ ๋จ์ ํ ์คํธ๋ฅผ ์์ฑํ์ฌ, ๋ค์ํ ํจ์ ์๊ทธ๋์ฒ์์ ์ฌ๋ฐ๋ฅด๊ฒ ์๋ํ๊ณ ๋ฉํ๋ฐ์ดํฐ๊ฐ ๋ณด์กด๋๋์ง ํ์ธํ์ญ์์ค.
- ๋ฐ์ฝ๋ ์ดํฐ ์์์ ์ ์ํ๊ธฐ: ์ฌ๋ฌ ๋ฐ์ฝ๋ ์ดํฐ๋ฅผ ์ ์ฉํ ๋, ๊ทธ ์์๊ฐ ์ค์ํฉ๋๋ค. ํจ์ ์ ์์ ๊ฐ์ฅ ๊ฐ๊น์ด ๋ฐ์ฝ๋ ์ดํฐ๊ฐ ๋จผ์ ์ ์ฉ๋ฉ๋๋ค. ์ด๋ ๋ฐ์ฝ๋ ์ดํฐ๋ค์ด ์ํธ ์์ฉํ๋ ๋ฐฉ์๊ณผ ๋ฉํ๋ฐ์ดํฐ๊ฐ ์ ์ฉ๋๋ ๋ฐฉ์์ ์ํฅ์ ๋ฏธ์นฉ๋๋ค. ์๋ฅผ ๋ค์ด, ์ฌ์ฉ์ ์ ์ ๋ฐ์ฝ๋ ์ดํฐ๋ฅผ ๊ตฌ์ฑํ๋ ๊ฒฝ์ฐ
@functools.wraps๋ ๊ฐ์ฅ ์์ชฝ์ ๋ํผ ํจ์์ ์ ์ฉ๋์ด์ผ ํฉ๋๋ค.
๋ฐ์ฝ๋ ์ดํฐ ๊ตฌํ ๋น๊ต
์์ฝํ์๋ฉด, ๋ ๊ฐ์ง ์ ๊ทผ ๋ฐฉ์์ ์ง์ ์ ์ธ ๋น๊ต๋ ๋ค์๊ณผ ๊ฐ์ต๋๋ค:
ํจ์ ๋ํ (๊ธฐ๋ณธ)
- ์ฅ์ : ๊ธฐ๋ฅ์ ๋น ๋ฅธ ์ถ๊ฐ๋ฅผ ์ํด ๊ตฌํ์ด ๊ฐ๋จํฉ๋๋ค.
- ๋จ์ : ์๋ณธ ํจ์์ ๋ฉํ๋ฐ์ดํฐ(์ด๋ฆ, ๋ ์คํธ๋ง ๋ฑ)๋ฅผ ํ๊ดดํ์ฌ ๋๋ฒ๊น ๋ฌธ์ , ๋ถ์คํ ์ธํธ๋ก์คํ์ , ์ ์ง๋ณด์์ฑ ์ ํ๋ฅผ ์ด๋ํฉ๋๋ค.
- ์ฌ์ฉ ์ฌ๋ก: ๋ฉํ๋ฐ์ดํฐ๊ฐ ์ค์ํ์ง ์์ ๋งค์ฐ ๊ฐ๋จํ๊ณ ์ผํ์ฑ์ธ ๋ฐ์ฝ๋ ์ดํฐ (๊ฑฐ์ ๊ถ์ฅ๋์ง ์์).
๋ฉํ๋ฐ์ดํฐ ๋ณด์กด (functools.wraps ์ฌ์ฉ)
- ์ฅ์ : ์๋ณธ ํจ์ ๋ฉํ๋ฐ์ดํฐ๋ฅผ ๋ณด์กดํ์ฌ ์ ํํ ์ธํธ๋ก์คํ์ , ์ฌ์ด ๋๋ฒ๊น , ๋ ๋์ ๋ฌธ์ํ, ํฅ์๋ ์ ์ง๋ณด์์ฑ์ ๋ณด์ฅํฉ๋๋ค. ๊ธ๋ก๋ฒ ํ์ ์ํ ์ฝ๋์ ๋ช ํ์ฑ๊ณผ ๊ฒฌ๊ณ ์ฑ์ ์ฆ์ง์ํต๋๋ค.
- ๋จ์ :
@functools.wrapsํฌํจ์ผ๋ก ์ธํด ์ฝ๊ฐ ๋ ์ฅํฉํฉ๋๋ค. - ์ฌ์ฉ ์ฌ๋ก: ํ๋ก๋์ ์ฝ๋, ํนํ ๊ณต์ ๋๊ฑฐ๋ ์คํ ์์ค ํ๋ก์ ํธ, ๋๋ ํ๋ ์์ํฌ์ ํจ๊ป ์์ ํ ๋์ ๊ฑฐ์ ๋ชจ๋ ๋ฐ์ฝ๋ ์ดํฐ ๊ตฌํ. ์ด๊ฒ์ ์ ๋ฌธ์ ์ธ ํ์ด์ฌ ๊ฐ๋ฐ์ ์ํ ํ์ค์ด์ ๊ถ์ฅ๋๋ ์ ๊ทผ ๋ฐฉ์์ ๋๋ค.
๊ฒฐ๋ก
ํ์ด์ฌ์ ๋ฐ์ฝ๋ ์ดํฐ ํจํด์ ์ฝ๋์ ๊ธฐ๋ฅ๊ณผ ๊ตฌ์กฐ๋ฅผ ํฅ์์ํค๋ ๊ฐ๋ ฅํ ๋๊ตฌ์
๋๋ค. ๊ธฐ๋ณธ์ ์ธ ํจ์ ๋ํ์ด ๊ฐ๋จํ ํ์ฅ์ ๋ฌ์ฑํ ์๋ ์์ง๋ง, ์ค์ํ ํจ์ ๋ฉํ๋ฐ์ดํฐ๋ฅผ ์๋ ์๋นํ ๋๊ฐ๋ฅผ ์น๋ฆ
๋๋ค. ์ ๋ฌธ์ ์ด๊ณ ์ ์ง๋ณด์ ๊ฐ๋ฅํ๋ฉฐ, ์ ์ธ๊ณ์ ์ผ๋ก ํ์
ํ๋ ์ํํธ์จ์ด ๊ฐ๋ฐ์์ functools.wraps๋ฅผ ์ฌ์ฉํ ๋ฉํ๋ฐ์ดํฐ ๋ณด์กด์ ๋จ์ํ ๋ชจ๋ฒ ์ฌ๋ก๊ฐ ์๋๋ผ ํ์์ ์
๋๋ค.
@functools.wraps๋ฅผ ์ผ๊ด๋๊ฒ ์ ์ฉํจ์ผ๋ก์จ, ๊ฐ๋ฐ์๋ค์ ๋ฐ์ฝ๋ ์ดํธ๋ ํจ์๊ฐ ์ธํธ๋ก์คํ์
, ๋๋ฒ๊น
, ๋ฌธ์ํ ์ธก๋ฉด์์ ์์๋๋ก ๋์ํ๋๋ก ๋ณด์ฅํ ์ ์์ต๋๋ค. ์ด๋ ๋ ๊นจ๋ํ๊ณ , ๋ ๊ฒฌ๊ณ ํ๋ฉฐ, ๋ ์ดํดํ๊ธฐ ์ฌ์ด ์ฝ๋๋ฒ ์ด์ค๋ก ์ด์ด์ง๋ฉฐ, ์ด๋ ์๋ก ๋ค๋ฅธ ์ง๋ฆฌ์ ์์น, ์๊ฐ๋, ๋ฌธํ์ ๋ฐฐ๊ฒฝ์์ ์์
ํ๋ ํ์๊ฒ ๋งค์ฐ ์ค์ํฉ๋๋ค. ๊ธ๋ก๋ฒ ์ฌ์ฉ์๋ฅผ ์ํ ๋ ๋์ ํ์ด์ฌ ์ ํ๋ฆฌ์ผ์ด์
์ ๊ตฌ์ถํ๊ธฐ ์ํด ์ด ๊ดํ์ ๋ฐ์๋ค์ด์ญ์์ค.